1class User:
2    def __init__(self, name: str, email: str):
3        self._id = str(uuid.uuid4())
4        self._name = name
5        self._email = email
6        self._balance_sheet = BalanceSheet(self)
7    
8    def get_id(self) -> str:
9        return self._id
10    
11    def get_name(self) -> str:
12        return self._name
13    
14    def get_balance_sheet(self) -> 'BalanceSheet':
15        return self._balance_sheet

1class Transaction:
2    def __init__(self, from_user: User, to_user: User, amount: float):
3        self._from = from_user
4        self._to = to_user
5        self._amount = amount
6    
7    def __str__(self) -> str:
8        return f"{self._from.get_name()} should pay {self._to.get_name()} ${self._amount:.2f}"

1class Split:
2    def __init__(self, user: User, amount: float):
3        self._user = user
4        self._amount = amount
5    
6    def get_user(self) -> User:
7        return self._user
8    
9    def get_amount(self) -> float:
10        return self._amount

1class Group:
2    def __init__(self, name: str, members: List[User]):
3        self._id = str(uuid.uuid4())
4        self._name = name
5        self._members = members
6    
7    def get_id(self) -> str:
8        return self._id
9    
10    def get_name(self) -> str:
11        return self._name
12    
13    def get_members(self) -> List[User]:
14        return self._members.copy()

1class Expense:
2    def __init__(self, builder: 'ExpenseBuilder'):
3        self._id = builder._id
4        self._description = builder._description
5        self._amount = builder._amount
6        self._paid_by = builder._paid_by
7        self._timestamp = datetime.now()
8        
9        # Use the strategy to calculate splits
10        self._splits = builder._split_strategy.calculate_splits(
11            builder._amount, builder._paid_by, builder._participants, builder._split_values
12        )
13    
14    def get_id(self) -> str:
15        return self._id
16    
17    def get_description(self) -> str:
18        return self._description
19    
20    def get_amount(self) -> float:
21        return self._amount
22    
23    def get_paid_by(self) -> User:
24        return self._paid_by
25    
26    def get_splits(self) -> List[Split]:
27        return self._splits
28    
29    class ExpenseBuilder:
30        def __init__(self):
31            self._id: Optional[str] = None
32            self._description: Optional[str] = None
33            self._amount: Optional[float] = None
34            self._paid_by: Optional[User] = None
35            self._participants: Optional[List[User]] = None
36            self._split_strategy: Optional[SplitStrategy] = None
37            self._split_values: Optional[List[float]] = None
38        
39        def set_id(self, expense_id: str) -> 'Expense.ExpenseBuilder':
40            self._id = expense_id
41            return self
42        
43        def set_description(self, description: str) -> 'Expense.ExpenseBuilder':
44            self._description = description
45            return self
46        
47        def set_amount(self, amount: float) -> 'Expense.ExpenseBuilder':
48            self._amount = amount
49            return self
50        
51        def set_paid_by(self, paid_by: User) -> 'Expense.ExpenseBuilder':
52            self._paid_by = paid_by
53            return self
54        
55        def set_participants(self, participants: List[User]) -> 'Expense.ExpenseBuilder':
56            self._participants = participants
57            return self
58        
59        def set_split_strategy(self, split_strategy: SplitStrategy) -> 'Expense.ExpenseBuilder':
60            self._split_strategy = split_strategy
61            return self
62        
63        def set_split_values(self, split_values: List[float]) -> 'Expense.ExpenseBuilder':
64            self._split_values = split_values
65            return self
66        
67        def build(self) -> 'Expense':
68            if self._split_strategy is None:
69                raise ValueError("Split strategy is required.")
70            return Expense(self)

1class BalanceSheet:
2    def __init__(self, owner: User):
3        self._owner = owner
4        self._balances: Dict[User, float] = {}
5        self._lock = threading.Lock()
6    
7    def get_balances(self) -> Dict[User, float]:
8        return self._balances
9    
10    def adjust_balance(self, other_user: User, amount: float):
11        with self._lock:
12            if self._owner == other_user:
13                return  # Cannot owe yourself
14            
15            if other_user in self._balances:
16                self._balances[other_user] += amount
17            else:
18                self._balances[other_user] = amount
19    
20    def show_balances(self):
21        print(f"--- Balance Sheet for {self._owner.get_name()} ---")
22        if not self._balances:
23            print("All settled up!")
24            return
25        
26        total_owed_to_me = 0
27        total_i_owe = 0
28        
29        for other_user, amount in self._balances.items():
30            if amount > 0.01:
31                print(f"{other_user.get_name()} owes {self._owner.get_name()} ${amount:.2f}")
32                total_owed_to_me += amount
33            elif amount < -0.01:
34                print(f"{self._owner.get_name()} owes {other_user.get_name()} ${-amount:.2f}")
35                total_i_owe += (-amount)
36        
37        print(f"Total Owed to {self._owner.get_name()}: ${total_owed_to_me:.2f}")
38        print(f"Total {self._owner.get_name()} Owes: ${total_i_owe:.2f}")
39        print("---------------------------------")

1class SplitStrategy(ABC):
2    @abstractmethod
3    def calculate_splits(self, total_amount: float, paid_by: User, participants: List[User], split_values: Optional[List[float]]) -> List[Split]:
4        pass
5
6class EqualSplitStrategy(SplitStrategy):
7    def calculate_splits(self, total_amount: float, paid_by: User, participants: List[User], split_values: Optional[List[float]]) -> List[Split]:
8        splits = []
9        amount_per_person = total_amount / len(participants)
10        for participant in participants:
11            splits.append(Split(participant, amount_per_person))
12        return splits
13
14class ExactSplitStrategy(SplitStrategy):
15    def calculate_splits(self, total_amount: float, paid_by: User, participants: List[User], split_values: Optional[List[float]]) -> List[Split]:
16        if len(participants) != len(split_values):
17            raise ValueError("Number of participants and split values must match.")
18        if abs(sum(split_values) - total_amount) > 0.01:
19            raise ValueError("Sum of exact amounts must equal the total expense amount.")
20        
21        splits = []
22        for i in range(len(participants)):
23            splits.append(Split(participants[i], split_values[i]))
24        return splits
25
26class PercentageSplitStrategy(SplitStrategy):
27    def calculate_splits(self, total_amount: float, paid_by: User, participants: List[User], split_values: Optional[List[float]]) -> List[Split]:
28        if len(participants) != len(split_values):
29            raise ValueError("Number of participants and split values must match.")
30        if abs(sum(split_values) - 100.0) > 0.01:
31            raise ValueError("Sum of percentages must be 100.")
32        
33        splits = []
34        for i in range(len(participants)):
35            amount = (total_amount * split_values[i]) / 100.0
36            splits.append(Split(participants[i], amount))
37        return splits

1class SplitwiseService:
2    _instance = None
3    _lock = threading.Lock()
4    
5    def __new__(cls):
6        if cls._instance is None:
7            with cls._lock:
8                if cls._instance is None:
9                    cls._instance = super().__new__(cls)
10                    cls._instance._initialized = False
11        return cls._instance
12    
13    def __init__(self):
14        if not self._initialized:
15            self._users: Dict[str, User] = {}
16            self._groups: Dict[str, Group] = {}
17            self._initialized = True
18    
19    @classmethod
20    def get_instance(cls):
21        return cls()
22    
23    def add_user(self, name: str, email: str) -> User:
24        user = User(name, email)
25        self._users[user.get_id()] = user
26        return user
27    
28    def add_group(self, name: str, members: List[User]) -> Group:
29        group = Group(name, members)
30        self._groups[group.get_id()] = group
31        return group
32    
33    def get_user(self, user_id: str) -> Optional[User]:
34        return self._users.get(user_id)
35    
36    def get_group(self, group_id: str) -> Optional[Group]:
37        return self._groups.get(group_id)
38    
39    def create_expense(self, builder: Expense.ExpenseBuilder):
40        with self._lock:
41            expense = builder.build()
42            paid_by = expense.get_paid_by()
43            
44            for split in expense.get_splits():
45                participant = split.get_user()
46                amount = split.get_amount()
47                
48                if paid_by != participant:
49                    paid_by.get_balance_sheet().adjust_balance(participant, amount)
50                    participant.get_balance_sheet().adjust_balance(paid_by, -amount)
51            
52            print(f"Expense '{expense.get_description()}' of amount {expense.get_amount()} created.")
53    
54    def settle_up(self, payer_id: str, payee_id: str, amount: float):
55        with self._lock:
56            payer = self._users[payer_id]
57            payee = self._users[payee_id]
58            print(f"{payer.get_name()} is settling up {amount} with {payee.get_name()}")
59            
60            # Settlement is like a reverse expense. payer owes less to payee.
61            payee.get_balance_sheet().adjust_balance(payer, -amount)
62            payer.get_balance_sheet().adjust_balance(payee, amount)
63    
64    def show_balance_sheet(self, user_id: str):
65        user = self._users[user_id]
66        user.get_balance_sheet().show_balances()
67    
68    def simplify_group_debts(self, group_id: str) -> List[Transaction]:
69        group = self._groups.get(group_id)
70        if group is None:
71            raise ValueError("Group not found")
72        
73        # Calculate net balance for each member within the group context
74        net_balances = {}
75        for member in group.get_members():
76            balance = 0
77            for other_user, amount in member.get_balance_sheet().get_balances().items():
78                # Consider only balances with other group members
79                if other_user in group.get_members():
80                    balance += amount
81            net_balances[member] = balance
82        
83        # Separate into creditors and debtors
84        creditors = [(user, balance) for user, balance in net_balances.items() if balance > 0]
85        debtors = [(user, balance) for user, balance in net_balances.items() if balance < 0]
86        
87        creditors.sort(key=lambda x: x[1], reverse=True)
88        debtors.sort(key=lambda x: x[1])
89        
90        transactions = []
91        i = j = 0
92        
93        while i < len(creditors) and j < len(debtors):
94            creditor_user, creditor_amount = creditors[i]
95            debtor_user, debtor_amount = debtors[j]
96            
97            amount_to_settle = min(creditor_amount, -debtor_amount)
98            transactions.append(Transaction(debtor_user, creditor_user, amount_to_settle))
99            
100            creditors[i] = (creditor_user, creditor_amount - amount_to_settle)
101            debtors[j] = (debtor_user, debtor_amount + amount_to_settle)
102            
103            if abs(creditors[i][1]) < 0.01:
104                i += 1
105            if abs(debtors[j][1]) < 0.01:
106                j += 1
107        
108        return transactions

1class SplitwiseDemo:
2    @staticmethod
3    def main():
4        # 1. Setup the service
5        service = SplitwiseService.get_instance()
6        
7        # 2. Create users and groups
8        alice = service.add_user("Alice", "[email protected]")
9        bob = service.add_user("Bob", "[email protected]")
10        charlie = service.add_user("Charlie", "[email protected]")
11        david = service.add_user("David", "[email protected]")
12        
13        friends_group = service.add_group("Friends Trip", [alice, bob, charlie, david])
14        
15        print("--- System Setup Complete ---\n")
16        
17        # 3. Use Case 1: Equal Split
18        print("--- Use Case 1: Equal Split ---")
19        service.create_expense(Expense.ExpenseBuilder()
20                              .set_description("Dinner")
21                              .set_amount(1000)
22                              .set_paid_by(alice)
23                              .set_participants([alice, bob, charlie, david])
24                              .set_split_strategy(EqualSplitStrategy()))
25        
26        service.show_balance_sheet(alice.get_id())
27        service.show_balance_sheet(bob.get_id())
28        print()
29        
30        # 4. Use Case 2: Exact Split
31        print("--- Use Case 2: Exact Split ---")
32        service.create_expense(Expense.ExpenseBuilder()
33                              .set_description("Movie Tickets")
34                              .set_amount(370)
35                              .set_paid_by(alice)
36                              .set_participants([bob, charlie])
37                              .set_split_strategy(ExactSplitStrategy())
38                              .set_split_values([120.0, 250.0]))
39        
40        service.show_balance_sheet(alice.get_id())
41        service.show_balance_sheet(bob.get_id())
42        print()
43        
44        # 5. Use Case 3: Percentage Split
45        print("--- Use Case 3: Percentage Split ---")
46        service.create_expense(Expense.ExpenseBuilder()
47                              .set_description("Groceries")
48                              .set_amount(500)
49                              .set_paid_by(david)
50                              .set_participants([alice, bob, charlie])
51                              .set_split_strategy(PercentageSplitStrategy())
52                              .set_split_values([40.0, 30.0, 30.0]))  # 40%, 30%, 30%
53        
54        print("--- Balances After All Expenses ---")
55        service.show_balance_sheet(alice.get_id())
56        service.show_balance_sheet(bob.get_id())
57        service.show_balance_sheet(charlie.get_id())
58        service.show_balance_sheet(david.get_id())
59        print()
60        
61        # 6. Use Case 4: Simplify Group Debts
62        print("--- Use Case 4: Simplify Group Debts for 'Friends Trip' ---")
63        simplified_debts = service.simplify_group_debts(friends_group.get_id())
64        if not simplified_debts:
65            print("All debts are settled within the group!")
66        else:
67            for debt in simplified_debts:
68                print(debt)
69        print()
70        
71        service.show_balance_sheet(bob.get_id())
72        
73        # 7. Use Case 5: Partial Settlement
74        print("--- Use Case 5: Partial Settlement ---")
75        # From the simplified debts, we see Bob should pay Alice. Let's say Bob pays 100.
76        service.settle_up(bob.get_id(), alice.get_id(), 100)
77        
78        print("--- Balances After Partial Settlement ---")
79        service.show_balance_sheet(alice.get_id())
80        service.show_balance_sheet(bob.get_id())
81
82if __name__ == "__main__":
83    SplitwiseDemo.main()